home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / SOURCE / FILE.C < prev    next >
C/C++ Source or Header  |  1994-05-15  |  10KB  |  285 lines
  1. /* File input and output                                           */
  2. /* Copyright (c) 1994 Coronado Enterprises                         */
  3.  
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <malloc.h>
  7. #include "vc.h"
  8. #include "video.h"
  9.  
  10. int lastline = 0;
  11. int arrowln = 0;
  12. extern struct lines *top, *bot, *q, *p, *arrow, *trnsend;
  13. extern struct vars allvars[];
  14. extern int varinuse;
  15. extern int printit;
  16. extern char inline[];
  17. extern int errcode;
  18. extern int ignore;
  19.  
  20.  
  21.  
  22. /********************************************************* fileout */
  23. /* This routine opens a disk file and writes the marked lines in   */
  24. /*  the transcript to that file.                                   */
  25. void fileout(void)
  26. {
  27. char *lpt, fileout[25];
  28. struct lines *pt;
  29. int i;
  30. FILE *fp2;
  31.  
  32.    poscurs(23, 1);                /* read in filename to output to */
  33.    printf("     filename >                    <");
  34.    poscurs(23, 17);
  35.    for (i = 0 ; (fileout[i] = getchar()) != '\n' ; ++i);
  36.    fileout[i] = 0;                /* filename read in ready to use */
  37.    fp2 = fopen(fileout, "w");     /* open file                     */
  38.    pt = top;                      /* start at top of llinked list  */
  39.    do {
  40.       lpt = pt->lineloc;          /* line of text stored           */
  41.       if (pt->marked){            /* only output marked lines      */
  42.          fputs(lpt, fp2);         /* output a line                 */
  43.          fputs("\n", fp2);        /* and a linefeed                */
  44.       }
  45.       pt = pt->dn;                /* get the next line             */
  46.    } while (pt != NULL);
  47.    fflush(fp2);                   /* flush the file to disk        */
  48.    fclose(fp2);                   /* close the file                */
  49.    poscurs(23, 7);
  50.    printf("  input >                     ");
  51. }
  52.  
  53.  
  54.  
  55. /********************************************************** filein */
  56. /* A diskfile is opened and read into the transcript window while  */
  57. /* all calculations are done as the file is input. If any errors   */
  58. /* are found, the calculations are not done, zero is returned as a */
  59. /* result and the remainder of the file is read in. It is assumed  */
  60. /* that the equations are correct before the file was originally   */
  61. /* written.                                                        */
  62. char filenam[25] = "help";       /* default filename to start with */
  63. void filein(void)
  64. {
  65. char filein[25];
  66. char *fc;
  67. int i;
  68. FILE *fp2;
  69.  
  70.    poscurs(23, 1);                /* read in filename for input    */
  71.    printf("     filename >                    <");
  72.    poscurs(23, 17);
  73.    for (i = 0 ; (filein[i] = getchar()) != '\n' ; ++i);
  74.    filein[i] = 0;                 /* filename read in ready to use */
  75.    if (filein[0] == 0)            /* if no filename was input      */
  76.       strcpy(filein, filenam);    /* use last valid filemane       */
  77.    else
  78.       strcpy(filenam, filein);    /* save for later use            */
  79.    fp2 = fopen(filein, "r");      /* open file                     */
  80.    if (fp2 == NULL) {             /* file doesn't exist            */
  81.       errcode = 11;
  82.       errout();
  83.    } else {
  84.       do {
  85.          fc = (fgets(inline, 62, fp2));
  86.          if (fc == NULL) break;
  87.          for (i=0 ; inline[i] ; ++i) /* change \n to zero          */
  88.             ;
  89.          inline[i-1] = 0;
  90.          parse();
  91.          if ((ignore == 1) || errcode)
  92.             strtrans(inline, 0);
  93.          else
  94.             strtrans(inline, 1);
  95.          transout();
  96.       } while (i != 0);
  97.    }
  98.    for (i = 0 ; i < 200 ; ++i) 
  99.       inline[i] = 0;               /* clear input area             */
  100.    poscurs(23, 7);
  101.    printf("  input >                      ");
  102. }
  103.  
  104.  
  105.  
  106. /******************************************************** strtrans */
  107. /* A line from the input area or from a file input is stored in    */
  108. /*  the transcript area. It is stored in the transcript array      */
  109. /*  here, and output to the transcript window in the "transout"    */
  110. /*  function.  This function uses a linked list to store the lines */
  111. /*  of data.                                                       */
  112. void strtrans(char line[], int type)
  113. {
  114. int i;
  115. long int temp;
  116. char *pt;
  117. char buffer[25];    /* this is long enough to include an overwrite */
  118. double xx;                        /* temporary variable            */
  119. extern FILE *prtfile;             /* print file output             */
  120.  
  121.    p = (struct lines *)malloc(sizeof(struct lines));
  122.    pt = (char *)malloc(1 + strlen(line));
  123.    if ((p == NULL) || (pt == NULL)) { /* out of memory             */
  124.       errcode = 13;
  125.       errout();
  126.    }
  127.  
  128.    else {                 /* there is enough memory for this entry */
  129.       if (top == NULL){           /* first entry                   */
  130.          top = bot = p;
  131.          p->dn = NULL;
  132.          p->up = NULL;
  133.       } else {                    /* additional entries            */
  134.          bot->dn = p;
  135.          p->up = bot;
  136.          p->dn = NULL;
  137.          bot = p;
  138.       }                           
  139.       p->lineloc = pt;
  140.       i = strlen(line);
  141.       p->isvalue = type;
  142.       p->marked = type;
  143.       p->linelngt = i;
  144.       if (type) {
  145.          xx = allvars[varinuse].value;
  146.          if (xx < 0.0) 
  147.             xx = -xx;
  148.          if ((xx > 9999999.0) || (xx < .001))
  149.             sprintf(buffer, "%12.5e", allvars[varinuse].value);
  150.          else
  151.             sprintf(buffer, "%12.6f", allvars[varinuse].value);
  152.          buffer[12] = 0;
  153.          if (varinuse > 5) {      /* variable I through N          */
  154.             temp = (long int)allvars[varinuse].value;
  155.             temp = temp & 077777777;
  156.             if (allvars[varinuse].outtype == 'D')
  157.                sprintf(buffer, "(D) %8ld", temp);
  158.             if (allvars[varinuse].outtype == 'O')
  159.                sprintf(buffer, "(O) %8lo", temp);
  160.             if ((allvars[varinuse].outtype == 'X') ||
  161.                 (allvars[varinuse].outtype == 'H'))
  162.                sprintf(buffer, "(H) %8lx", temp);
  163.          }
  164.          strcpy(p->strval, buffer);
  165.       } else
  166.          strcpy(p->strval,"            ");
  167.       line[i] = '\0';             /* line terminator               */
  168.       strcpy(pt, line);
  169.       if (type && printit) {
  170.          fprintf(prtfile, "%13s  %-62s\n", buffer, line);
  171.       }
  172.       arrow = p;
  173.       trnsend = p;
  174.       lastline++;
  175.       arrowln = lastline;
  176.    }
  177. }
  178.  
  179.  
  180.  
  181. /******************************************************** transout */
  182. /* This function outputs the transcript to the transcript window.  */
  183. extern char strngout[];
  184. void transout(void)
  185. {
  186. int i;
  187. int maxm = 13;      /* number of lines to output to the trans wind */
  188. char *pt;
  189.  
  190.    p = trnsend;
  191.    for (i = 0 ; i < maxm ; ++i){  /* count up max from trnsend     */
  192.       if (p->up == NULL) 
  193.          break;                   /* stop if top found             */
  194.       p = p->up;
  195.    }
  196.    for (i = 0 ; i <= maxm ; ++i){ /* output max fields to viddisp  */
  197.       pt = p->lineloc;            /* pt now points to the line     */
  198.       strcpy(strngout, p->strval);
  199.       strngdis_trns(8 + i, 1);    /* output the formatted value    */
  200.       strcpy(strngout, pt);
  201.       blnkline(8 + i, 16);        /* write blanks to line          */
  202.       if (p->marked)
  203.          chardis_trns(8 + i, 15, '*'); /* marked indicator         */
  204.       else
  205.          chardis_trns(8 + i, 15, ' '); /* blank                    */
  206.       strngdis_trns(8 + i, 17);
  207.       if (arrow == p)
  208.          chardis_trns(8 + i, 14, 16); /* arrow char                */
  209.       else               
  210.          chardis_trns(8 + i, 14,' '); /* blank                     */
  211.       if (p->dn == NULL) break;   /* stop if bottom found          */
  212.       p = p->dn;
  213.    }
  214.    poscurs(23, 3);
  215.    printf("%4d", arrowln);
  216. }
  217.  
  218.  
  219.  
  220. /******************************************************** movarrow */
  221. /* This function is used to move the arrow up or down in the       */
  222. /*  window and to control where the window begins and ends in the  */
  223. /*  transcript data. The arrow is always two lines from the top or */
  224. /*  bottom if it is possible to do so.                             */
  225. void movarrow(int where)
  226. {
  227. int index;
  228. struct lines *temp;
  229. int iend, iarrow, itrnsend;
  230.  
  231.    iend = iarrow = itrnsend = 0;
  232.    if (where > 0) {
  233.       for (index = where ; index && (arrow != bot) ; --index)
  234.          arrow = arrow->dn;       /* move arrow down one           */
  235.       for (temp = top, index = 0 ; temp != bot ; index++) {
  236.          if (temp == arrow) 
  237.             iarrow = index;       /* locate arrow                  */
  238.          if (temp == trnsend) 
  239.             itrnsend = index;     /* loc display end               */
  240.          temp = temp->dn;
  241.       }
  242.       if (temp == arrow) 
  243.          iarrow = index;          /* if they are at                */
  244.       if (temp == trnsend) 
  245.          itrnsend = index;        /* the bottom end                */
  246.       iend = index;
  247.           /* now trnsend must be >= arrow, but not by more than 10 */
  248.       if (iarrow == iend) 
  249.          index = iend - itrnsend;
  250.       else if (itrnsend < (iarrow+1)) 
  251.          index = iarrow - itrnsend + 1;
  252.       else index = 0;
  253.    } else {
  254.       for (index = -where ; index && (arrow != top) ; --index)
  255.          arrow = arrow->up;       /* move arrow up one             */
  256.       for (temp = top,index = 0 ; temp != bot ; index++) {
  257.          if (temp == arrow) 
  258.             iarrow = index;       /* locate arrow                  */
  259.          if (temp == trnsend) 
  260.             itrnsend = index;     /* loc display end               */
  261.          temp = temp->dn;
  262.       }
  263.       if (temp == arrow) 
  264.          iarrow = index;          /* if they are at                */
  265.       if (temp == trnsend) 
  266.          itrnsend = index;        /* the bottom end                */
  267.       iend = index;
  268.           /* now trnsend must be >= arrow, but not by more than 12 */
  269.       if (iarrow == 0) 
  270.          index = (iend > 13 ? 13 : iend) - itrnsend;
  271.       else if ((itrnsend - iarrow) > 12) 
  272.          index = iarrow - itrnsend + 12;
  273.       else 
  274.          index = 0;
  275.    }
  276.    if (index > 0)
  277.       for ( ; index > 0 ; --index)
  278.          trnsend = trnsend->dn;
  279.    else if (index < 0)
  280.       for ( ; index < 0 ; ++index)
  281.          trnsend = trnsend->up;
  282.    arrowln = iarrow;
  283.    transout();
  284. }
  285.